#include "st-adjustment.h"
#include "st-private.h"
+typedef struct _StAdjustmentPrivate StAdjustmentPrivate;
+
struct _StAdjustmentPrivate
{
/* Do not sanity-check values while constructing,
{
GObjectClass *g_class;
StAdjustment *self = ST_ADJUSTMENT (object);
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (self);
g_class = G_OBJECT_CLASS (st_adjustment_parent_class);
/* The docs say we're suppose to chain up, but would crash without
g_class->constructed (object);
}
- ST_ADJUSTMENT (self)->priv->is_constructing = FALSE;
- st_adjustment_clamp_page (self, self->priv->lower, self->priv->upper);
+ priv->is_constructing = FALSE;
+ st_adjustment_clamp_page (self, priv->lower, priv->upper);
}
static void
GValue *value,
GParamSpec *pspec)
{
- StAdjustmentPrivate *priv = ST_ADJUSTMENT (gobject)->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (ST_ADJUSTMENT (gobject));
switch (prop_id)
{
static void
st_adjustment_init (StAdjustment *self)
{
- self->priv = st_adjustment_get_instance_private (self);
-
- self->priv->is_constructing = TRUE;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (self);
+ priv->is_constructing = TRUE;
}
StAdjustment *
gdouble
st_adjustment_get_value (StAdjustment *adjustment)
{
- StAdjustmentPrivate *priv;
-
g_return_val_if_fail (ST_IS_ADJUSTMENT (adjustment), 0);
- priv = adjustment->priv;
-
- return priv->value;
+ return ((StAdjustmentPrivate *)st_adjustment_get_instance_private (adjustment))->value;
}
void
g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
- priv = adjustment->priv;
+ priv = st_adjustment_get_instance_private (adjustment);
/* Defer clamp until after construction. */
if (!priv->is_constructing)
g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
- priv = adjustment->priv;
+ priv = st_adjustment_get_instance_private (adjustment);
lower = CLAMP (lower, priv->lower, priv->upper - priv->page_size);
upper = CLAMP (upper, priv->lower + priv->page_size, priv->upper);
st_adjustment_set_lower (StAdjustment *adjustment,
gdouble lower)
{
- StAdjustmentPrivate *priv = adjustment->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (adjustment);
if (priv->lower != lower)
{
st_adjustment_set_upper (StAdjustment *adjustment,
gdouble upper)
{
- StAdjustmentPrivate *priv = adjustment->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (adjustment);
if (priv->upper != upper)
{
st_adjustment_set_step_increment (StAdjustment *adjustment,
gdouble step)
{
- StAdjustmentPrivate *priv = adjustment->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (adjustment);
if (priv->step_increment != step)
{
st_adjustment_set_page_increment (StAdjustment *adjustment,
gdouble page)
{
- StAdjustmentPrivate *priv = adjustment->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (adjustment);
if (priv->page_increment != page)
{
st_adjustment_set_page_size (StAdjustment *adjustment,
gdouble size)
{
- StAdjustmentPrivate *priv = adjustment->priv;
+ StAdjustmentPrivate *priv = st_adjustment_get_instance_private (adjustment);
if (priv->page_size != size)
{
g_return_if_fail (step_increment >= 0 && step_increment <= G_MAXDOUBLE);
g_return_if_fail (page_increment >= 0 && page_increment <= G_MAXDOUBLE);
- priv = adjustment->priv;
+ priv = st_adjustment_get_instance_private (adjustment);
emit_changed = FALSE;
g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
- priv = adjustment->priv;
+ priv = st_adjustment_get_instance_private (adjustment);
if (lower)
*lower = priv->lower;
g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
- priv = adjustment->priv;
+ priv = st_adjustment_get_instance_private (adjustment);
scroll_unit = pow (priv->page_size, 2.0 / 3.0);
G_BEGIN_DECLS
-#define ST_TYPE_ADJUSTMENT (st_adjustment_get_type())
-#define ST_ADJUSTMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_ADJUSTMENT, StAdjustment))
-#define ST_IS_ADJUSTMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_ADJUSTMENT))
-#define ST_ADJUSTMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_ADJUSTMENT, StAdjustmentClass))
-#define ST_IS_ADJUSTMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_ADJUSTMENT))
-#define ST_ADJUSTMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_ADJUSTMENT, StAdjustmentClass))
-
-typedef struct _StAdjustment StAdjustment;
-typedef struct _StAdjustmentPrivate StAdjustmentPrivate;
-typedef struct _StAdjustmentClass StAdjustmentClass;
-
-/**
- * StAdjustment:
- *
- * Class for handling an interval between to values. The contents of
- * the #StAdjustment are private and should be accessed using the
- * public API.
- */
-struct _StAdjustment
-{
- /*< private >*/
- GObject parent_instance;
-
- StAdjustmentPrivate *priv;
-};
+#define ST_TYPE_ADJUSTMENT (st_adjustment_get_type())
+G_DECLARE_DERIVABLE_TYPE (StAdjustment, st_adjustment, ST, ADJUSTMENT, GObject)
/**
* StAdjustmentClass:
void (* changed) (StAdjustment *adjustment);
};
-GType st_adjustment_get_type (void) G_GNUC_CONST;
-
StAdjustment *st_adjustment_new (gdouble value,
gdouble lower,
gdouble upper,
#include "st-enum-types.h"
#include "st-private.h"
+typedef struct _StBinPrivate StBinPrivate;
struct _StBinPrivate
{
ClutterActor *child;
st_bin_remove (ClutterContainer *container,
ClutterActor *actor)
{
- StBinPrivate *priv = ST_BIN (container)->priv;
+ StBin *bin = ST_BIN (container);
+ StBinPrivate *priv = st_bin_get_instance_private (bin);
if (priv->child == actor)
- st_bin_set_child (ST_BIN (container), NULL);
+ st_bin_set_child (bin, NULL);
}
static void
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
- StBinPrivate *priv = ST_BIN (self)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (self));
clutter_actor_set_allocation (self, box, flags);
gfloat *min_width_p,
gfloat *natural_width_p)
{
- StBinPrivate *priv = ST_BIN (self)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (self));
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
st_theme_node_adjust_for_height (theme_node, &for_height);
gfloat *min_height_p,
gfloat *natural_height_p)
{
- StBinPrivate *priv = ST_BIN (self)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (self));
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
st_theme_node_adjust_for_width (theme_node, &for_width);
static void
st_bin_dispose (GObject *gobject)
{
- StBinPrivate *priv = ST_BIN (gobject)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (gobject));
if (priv->child)
clutter_actor_destroy (priv->child);
static void
st_bin_popup_menu (StWidget *widget)
{
- StBinPrivate *priv = ST_BIN (widget)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (widget));
if (priv->child && ST_IS_WIDGET (priv->child))
st_widget_popup_menu (ST_WIDGET (priv->child));
ClutterActor *from,
GtkDirectionType direction)
{
- StBinPrivate *priv = ST_BIN (widget)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (widget));
ClutterActor *bin_actor = CLUTTER_ACTOR (widget);
if (st_widget_get_can_focus (widget))
GParamSpec *pspec)
{
StBin *bin = ST_BIN (gobject);
+ StBinPrivate *priv = st_bin_get_instance_private (bin);
switch (prop_id)
{
case PROP_X_ALIGN:
st_bin_set_alignment (bin,
g_value_get_enum (value),
- bin->priv->y_align);
+ priv->y_align);
break;
case PROP_Y_ALIGN:
st_bin_set_alignment (bin,
- bin->priv->x_align,
+ priv->x_align,
g_value_get_enum (value));
break;
case PROP_X_FILL:
st_bin_set_fill (bin,
g_value_get_boolean (value),
- bin->priv->y_fill);
+ priv->y_fill);
break;
case PROP_Y_FILL:
st_bin_set_fill (bin,
- bin->priv->x_fill,
+ priv->x_fill,
g_value_get_boolean (value));
break;
GValue *value,
GParamSpec *pspec)
{
- StBinPrivate *priv = ST_BIN (gobject)->priv;
+ StBinPrivate *priv = st_bin_get_instance_private (ST_BIN (gobject));
switch (prop_id)
{
static void
st_bin_init (StBin *bin)
{
- bin->priv = st_bin_get_instance_private (bin);
+ StBinPrivate *priv = st_bin_get_instance_private (bin);
- bin->priv->x_align = ST_ALIGN_MIDDLE;
- bin->priv->y_align = ST_ALIGN_MIDDLE;
+ priv->x_align = ST_ALIGN_MIDDLE;
+ priv->y_align = ST_ALIGN_MIDDLE;
}
/**
g_return_if_fail (ST_IS_BIN (bin));
g_return_if_fail (child == NULL || CLUTTER_IS_ACTOR (child));
- priv = bin->priv;
+ priv = st_bin_get_instance_private (bin);
if (priv->child == child)
return;
{
g_return_val_if_fail (ST_IS_BIN (bin), NULL);
- return bin->priv->child;
+ return ((StBinPrivate *)st_bin_get_instance_private (bin))->child;
}
/**
g_return_if_fail (ST_IS_BIN (bin));
- priv = bin->priv;
+ priv = st_bin_get_instance_private (bin);
g_object_freeze_notify (G_OBJECT (bin));
g_return_if_fail (ST_IS_BIN (bin));
- priv = bin->priv;
+ priv = st_bin_get_instance_private (bin);
if (x_align)
*x_align = priv->x_align;
g_return_if_fail (ST_IS_BIN (bin));
- priv = bin->priv;
+ priv = st_bin_get_instance_private (bin);
g_object_freeze_notify (G_OBJECT (bin));
gboolean *x_fill,
gboolean *y_fill)
{
+ StBinPrivate *priv;
+
g_return_if_fail (ST_IS_BIN (bin));
+ priv = st_bin_get_instance_private (bin);
+
if (x_fill)
- *x_fill = bin->priv->x_fill;
+ *x_fill = priv->x_fill;
if (y_fill)
- *y_fill = bin->priv->y_fill;
+ *y_fill = priv->y_fill;
}
G_BEGIN_DECLS
#define ST_TYPE_BIN (st_bin_get_type ())
-#define ST_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_BIN, StBin))
-#define ST_IS_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_BIN))
-#define ST_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BIN, StBinClass))
-#define ST_IS_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BIN))
-#define ST_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BIN, StBinClass))
-
-typedef struct _StBin StBin;
-typedef struct _StBinPrivate StBinPrivate;
-typedef struct _StBinClass StBinClass;
-
-/**
- * StBin:
- *
- * The #StBin struct contains only private data
- */
-struct _StBin
-{
- /*< private >*/
- StWidget parent_instance;
-
- StBinPrivate *priv;
-};
+G_DECLARE_DERIVABLE_TYPE (StBin, st_bin, ST, BIN, StWidget)
/**
* StBinClass:
StWidgetClass parent_class;
};
-GType st_bin_get_type (void) G_GNUC_CONST;
-
StWidget * st_bin_new (void);
void st_bin_set_child (StBin *bin,
ClutterActor *child);
/* A StBorderImage encapsulates an image with specified unscaled borders on each edge.
*/
-typedef struct _StBorderImage StBorderImage;
-typedef struct _StBorderImageClass StBorderImageClass;
#define ST_TYPE_BORDER_IMAGE (st_border_image_get_type ())
-#define ST_BORDER_IMAGE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_BORDER_IMAGE, StBorderImage))
-#define ST_BORDER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BORDER_IMAGE, StBorderImageClass))
-#define ST_IS_BORDER_IMAGE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_BORDER_IMAGE))
-#define ST_IS_BORDER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BORDER_IMAGE))
-#define ST_BORDER_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BORDER_IMAGE, StBorderImageClass))
-
-GType st_border_image_get_type (void) G_GNUC_CONST;
+G_DECLARE_FINAL_TYPE (StBorderImage, st_border_image, ST, BORDER_IMAGE, GObject)
StBorderImage *st_border_image_new (GFile *file,
int border_top,
G_BEGIN_DECLS
#define ST_TYPE_BOX_LAYOUT_CHILD st_box_layout_child_get_type()
-
-#define ST_BOX_LAYOUT_CHILD(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
- ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChild))
-
-#define ST_BOX_LAYOUT_CHILD_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), \
- ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChildClass))
-
-#define ST_IS_BOX_LAYOUT_CHILD(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
- ST_TYPE_BOX_LAYOUT_CHILD))
-
-#define ST_IS_BOX_LAYOUT_CHILD_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), \
- ST_TYPE_BOX_LAYOUT_CHILD))
-
-#define ST_BOX_LAYOUT_CHILD_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), \
- ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChildClass))
+G_DECLARE_FINAL_TYPE (StBoxLayoutChild, st_box_layout_child, ST, BOX_LAYOUT_CHILD, ClutterChildMeta)
typedef struct _StBoxLayoutChild StBoxLayoutChild;
-typedef struct _StBoxLayoutChildClass StBoxLayoutChildClass;
typedef struct _StBoxLayoutChildPrivate StBoxLayoutChildPrivate;
/**
gboolean y_fill_set;
};
-struct _StBoxLayoutChildClass
-{
- ClutterChildMetaClass parent_class;
-};
-
-GType st_box_layout_child_get_type (void);
-
G_END_DECLS
#endif /* _ST_BOX_LAYOUT_CHILD_H */
G_BEGIN_DECLS
#define ST_TYPE_BOX_LAYOUT st_box_layout_get_type()
-
-#define ST_BOX_LAYOUT(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
- ST_TYPE_BOX_LAYOUT, StBoxLayout))
-
-#define ST_BOX_LAYOUT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), \
- ST_TYPE_BOX_LAYOUT, StBoxLayoutClass))
-
-#define ST_IS_BOX_LAYOUT(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
- ST_TYPE_BOX_LAYOUT))
-
-#define ST_IS_BOX_LAYOUT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), \
- ST_TYPE_BOX_LAYOUT))
-
-#define ST_BOX_LAYOUT_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), \
- ST_TYPE_BOX_LAYOUT, StBoxLayoutClass))
+G_DECLARE_FINAL_TYPE (StBoxLayout, st_box_layout, ST, BOX_LAYOUT, StWidget)
typedef struct _StBoxLayout StBoxLayout;
-typedef struct _StBoxLayoutClass StBoxLayoutClass;
typedef struct _StBoxLayoutPrivate StBoxLayoutPrivate;
/**
StBoxLayoutPrivate *priv;
};
-struct _StBoxLayoutClass
-{
- StWidgetClass parent_class;
-};
-
-GType st_box_layout_get_type (void);
-
StWidget *st_box_layout_new (void);
void st_box_layout_set_vertical (StBoxLayout *box,
LAST_SIGNAL
};
+typedef struct _StButtonPrivate StButtonPrivate;
+
struct _StButtonPrivate
{
gchar *text;
st_button_style_changed (StWidget *widget)
{
StButton *button = ST_BUTTON (widget);
- StButtonPrivate *priv = button->priv;
+ StButtonPrivate *priv = st_button_get_instance_private (button);
StButtonClass *button_class = ST_BUTTON_GET_CLASS (button);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (button));
double spacing;
StButtonMask mask,
ClutterEventSequence *sequence)
{
- if (button->priv->pressed == 0 || sequence)
+ StButtonPrivate *priv = st_button_get_instance_private (button);
+
+ if (priv->pressed == 0 || sequence)
st_widget_add_style_pseudo_class (ST_WIDGET (button), "active");
- button->priv->pressed |= mask;
- button->priv->press_sequence = sequence;
- button->priv->device = device;
+ priv->pressed |= mask;
+ priv->press_sequence = sequence;
+ priv->device = device;
}
static void
int clicked_button,
ClutterEventSequence *sequence)
{
- if ((device && button->priv->device != device) ||
- (sequence && button->priv->press_sequence != sequence))
+ StButtonPrivate *priv = st_button_get_instance_private (button);
+
+ if ((device && priv->device != device) ||
+ (sequence && priv->press_sequence != sequence))
return;
else if (!sequence)
{
- button->priv->pressed &= ~mask;
+ priv->pressed &= ~mask;
- if (button->priv->pressed != 0)
+ if (priv->pressed != 0)
return;
}
- button->priv->press_sequence = NULL;
- button->priv->device = NULL;
+ priv->press_sequence = NULL;
+ priv->device = NULL;
st_widget_remove_style_pseudo_class (ST_WIDGET (button), "active");
if (clicked_button || sequence)
{
- if (button->priv->is_toggle)
- st_button_set_checked (button, !button->priv->is_checked);
+ if (priv->is_toggle)
+ st_button_set_checked (button, !priv->is_checked);
g_signal_emit (button, button_signals[CLICKED], 0, clicked_button);
}
ClutterButtonEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
StButtonMask mask = ST_BUTTON_MASK_FROM_BUTTON (event->button);
ClutterInputDevice *device = clutter_event_get_device ((ClutterEvent*) event);
- if (button->priv->press_sequence)
+ if (priv->press_sequence)
return CLUTTER_EVENT_PROPAGATE;
- if (button->priv->button_mask & mask)
+ if (priv->button_mask & mask)
{
- if (button->priv->grabbed == 0)
+ if (priv->grabbed == 0)
clutter_grab_pointer (actor);
- button->priv->grabbed |= mask;
+ priv->grabbed |= mask;
st_button_press (button, device, mask, NULL);
return TRUE;
ClutterButtonEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
StButtonMask mask = ST_BUTTON_MASK_FROM_BUTTON (event->button);
ClutterInputDevice *device = clutter_event_get_device ((ClutterEvent*) event);
- if (button->priv->button_mask & mask)
+ if (priv->button_mask & mask)
{
gboolean is_click;
- is_click = button->priv->grabbed && clutter_actor_contains (actor, event->source);
+ is_click = priv->grabbed && clutter_actor_contains (actor, event->source);
st_button_release (button, device, mask, is_click ? event->button : 0, NULL);
- button->priv->grabbed &= ~mask;
- if (button->priv->grabbed == 0)
+ priv->grabbed &= ~mask;
+ if (priv->grabbed == 0)
clutter_ungrab_pointer ();
return TRUE;
ClutterTouchEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
StButtonMask mask = ST_BUTTON_MASK_FROM_BUTTON (1);
ClutterEventSequence *sequence;
ClutterInputDevice *device;
- if (button->priv->pressed != 0)
+ if (priv->pressed != 0)
return CLUTTER_EVENT_PROPAGATE;
device = clutter_event_get_device ((ClutterEvent*) event);
sequence = clutter_event_get_event_sequence ((ClutterEvent*) event);
- if (event->type == CLUTTER_TOUCH_BEGIN && !button->priv->press_sequence)
+ if (event->type == CLUTTER_TOUCH_BEGIN && !priv->press_sequence)
{
clutter_input_device_sequence_grab (device, sequence, actor);
st_button_press (button, device, 0, sequence);
return CLUTTER_EVENT_STOP;
}
else if (event->type == CLUTTER_TOUCH_END &&
- button->priv->device == device &&
- button->priv->press_sequence == sequence)
+ priv->device == device &&
+ priv->press_sequence == sequence)
{
st_button_release (button, device, mask, 0, sequence);
clutter_input_device_sequence_ungrab (device, sequence);
ClutterKeyEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
- if (button->priv->button_mask & ST_BUTTON_ONE)
+ if (priv->button_mask & ST_BUTTON_ONE)
{
if (event->keyval == CLUTTER_KEY_space ||
event->keyval == CLUTTER_KEY_Return ||
ClutterKeyEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
- if (button->priv->button_mask & ST_BUTTON_ONE)
+ if (priv->button_mask & ST_BUTTON_ONE)
{
if (event->keyval == CLUTTER_KEY_space ||
event->keyval == CLUTTER_KEY_Return ||
{
gboolean is_click;
- is_click = (button->priv->pressed & ST_BUTTON_ONE);
+ is_click = (priv->pressed & ST_BUTTON_ONE);
st_button_release (button, NULL, ST_BUTTON_ONE, is_click ? 1 : 0, NULL);
return TRUE;
}
st_button_key_focus_out (ClutterActor *actor)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
/* If we lose focus between a key press and release, undo the press */
- if ((button->priv->pressed & ST_BUTTON_ONE) &&
- !(button->priv->grabbed & ST_BUTTON_ONE))
+ if ((priv->pressed & ST_BUTTON_ONE) &&
+ !(priv->grabbed & ST_BUTTON_ONE))
st_button_release (button, NULL, ST_BUTTON_ONE, 0, NULL);
CLUTTER_ACTOR_CLASS (st_button_parent_class)->key_focus_out (actor);
ClutterCrossingEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
gboolean ret;
ret = CLUTTER_ACTOR_CLASS (st_button_parent_class)->enter_event (actor, event);
- if (button->priv->grabbed)
+ if (priv->grabbed)
{
if (st_widget_get_hover (ST_WIDGET (button)))
- st_button_press (button, button->priv->device,
- button->priv->grabbed, NULL);
+ st_button_press (button, priv->device,
+ priv->grabbed, NULL);
else
- st_button_release (button, button->priv->device,
- button->priv->grabbed, 0, NULL);
+ st_button_release (button, priv->device,
+ priv->grabbed, 0, NULL);
}
return ret;
ClutterCrossingEvent *event)
{
StButton *button = ST_BUTTON (actor);
+ StButtonPrivate *priv = st_button_get_instance_private (button);
gboolean ret;
ret = CLUTTER_ACTOR_CLASS (st_button_parent_class)->leave_event (actor, event);
- if (button->priv->grabbed)
+ if (priv->grabbed)
{
if (st_widget_get_hover (ST_WIDGET (button)))
- st_button_press (button, button->priv->device,
- button->priv->grabbed, NULL);
+ st_button_press (button, priv->device,
+ priv->grabbed, NULL);
else
- st_button_release (button, button->priv->device,
- button->priv->grabbed, 0, NULL);
+ st_button_release (button, priv->device,
+ priv->grabbed, 0, NULL);
}
return ret;
GValue *value,
GParamSpec *pspec)
{
- StButtonPrivate *priv = ST_BUTTON (gobject)->priv;
+ StButtonPrivate *priv = st_button_get_instance_private (ST_BUTTON (gobject));
switch (prop_id)
{
static void
st_button_finalize (GObject *gobject)
{
- StButtonPrivate *priv = ST_BUTTON (gobject)->priv;
+ StButtonPrivate *priv = st_button_get_instance_private (ST_BUTTON (gobject));
g_free (priv->text);
static void
st_button_init (StButton *button)
{
- button->priv = st_button_get_instance_private (button);
- button->priv->spacing = 6;
- button->priv->button_mask = ST_BUTTON_ONE;
+ StButtonPrivate *priv = st_button_get_instance_private (button);
+
+ priv->spacing = 6;
+ priv->button_mask = ST_BUTTON_ONE;
clutter_actor_set_reactive (CLUTTER_ACTOR (button), TRUE);
st_widget_set_track_hover (ST_WIDGET (button), TRUE);
{
g_return_val_if_fail (ST_IS_BUTTON (button), NULL);
- return button->priv->text;
+ return ((StButtonPrivate *)st_button_get_instance_private (button))->text;
}
/**
g_return_if_fail (ST_IS_BUTTON (button));
- priv = button->priv;
+ priv = st_button_get_instance_private (button);
g_free (priv->text);
{
g_return_val_if_fail (ST_IS_BUTTON (button), 0);
- return button->priv->button_mask;
+ return ((StButtonPrivate *)st_button_get_instance_private (button))->button_mask;
}
/**
st_button_set_button_mask (StButton *button,
StButtonMask mask)
{
+ StButtonPrivate *priv;
+
g_return_if_fail (ST_IS_BUTTON (button));
- button->priv->button_mask = mask;
+ priv = st_button_get_instance_private (button);
+ priv->button_mask = mask;
g_object_notify (G_OBJECT (button), "button-mask");
}
{
g_return_val_if_fail (ST_IS_BUTTON (button), FALSE);
- return button->priv->is_toggle;
+ return ((StButtonPrivate *)st_button_get_instance_private (button))->is_toggle;
}
/**
st_button_set_toggle_mode (StButton *button,
gboolean toggle)
{
+ StButtonPrivate *priv;
+
g_return_if_fail (ST_IS_BUTTON (button));
- button->priv->is_toggle = toggle;
+ priv = st_button_get_instance_private (button);
+ priv->is_toggle = toggle;
g_object_notify (G_OBJECT (button), "toggle-mode");
}
{
g_return_val_if_fail (ST_IS_BUTTON (button), FALSE);
- return button->priv->is_checked;
+ return ((StButtonPrivate *)st_button_get_instance_private (button))->is_checked;
}
/**
st_button_set_checked (StButton *button,
gboolean checked)
{
+ StButtonPrivate *priv;
+
g_return_if_fail (ST_IS_BUTTON (button));
- if (button->priv->is_checked != checked)
+ priv = st_button_get_instance_private (button);
+ if (priv->is_checked != checked)
{
- button->priv->is_checked = checked;
+ priv->is_checked = checked;
if (checked)
st_widget_add_style_pseudo_class (ST_WIDGET (button), "checked");
void
st_button_fake_release (StButton *button)
{
- if (button->priv->pressed)
- st_button_release (button, button->priv->device,
- button->priv->pressed, 0, NULL);
+ StButtonPrivate *priv;
+
+ g_return_if_fail (ST_IS_BUTTON (button));
+
+ priv = st_button_get_instance_private (button);
+ if (priv->pressed)
+ st_button_release (button, priv->device,
+ priv->pressed, 0, NULL);
- if (button->priv->grabbed)
+ if (priv->grabbed)
{
- button->priv->grabbed = 0;
+ priv->grabbed = 0;
clutter_ungrab_pointer ();
}
- if (button->priv->device &&
- button->priv->press_sequence)
+ if (priv->device &&
+ priv->press_sequence)
{
- clutter_input_device_sequence_ungrab (button->priv->device,
- button->priv->press_sequence);
- button->priv->press_sequence = NULL;
+ clutter_input_device_sequence_ungrab (priv->device,
+ priv->press_sequence);
+ priv->press_sequence = NULL;
}
- button->priv->device = NULL;
+ priv->device = NULL;
}
/******************************************************************************/
if (name != NULL)
return name;
- return button->priv->text;
+ return st_button_get_label (button);
}
static void
st_button_accessible_compute_role (AtkObject *accessible,
StButton *button)
{
- atk_object_set_role (accessible, button->priv->is_toggle
+ atk_object_set_role (accessible, st_button_get_toggle_mode (button)
? ATK_ROLE_TOGGLE_BUTTON : ATK_ROLE_PUSH_BUTTON);
}
#include <st/st-bin.h>
-#define ST_TYPE_BUTTON (st_button_get_type ())
-#define ST_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_BUTTON, StButton))
-#define ST_IS_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_BUTTON))
-#define ST_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BUTTON, StButtonClass))
-#define ST_IS_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BUTTON))
-#define ST_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BUTTON, StButtonClass))
-
-typedef struct _StButton StButton;
-typedef struct _StButtonPrivate StButtonPrivate;
-typedef struct _StButtonClass StButtonClass;
-
-/**
- * StButton:
- *
- * The contents of this structure is private and should only be accessed using
- * the provided API.
- */
-
-struct _StButton
-{
- /*< private >*/
- StBin parent_instance;
-
- StButtonPrivate *priv;
-};
+#define ST_TYPE_BUTTON (st_button_get_type ())
+G_DECLARE_DERIVABLE_TYPE (StButton, st_button, ST, BUTTON, StBin)
struct _StButtonClass
{
void (* clicked) (StButton *button);
};
-GType st_button_get_type (void) G_GNUC_CONST;
-
StWidget *st_button_new (void);
StWidget *st_button_new_with_label (const gchar *text);
const gchar *st_button_get_label (StButton *button);
G_BEGIN_DECLS
#define ST_TYPE_CLIPBOARD st_clipboard_get_type()
-
-#define ST_CLIPBOARD(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
- ST_TYPE_CLIPBOARD, StClipboard))
-
-#define ST_CLIPBOARD_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), \
- ST_TYPE_CLIPBOARD, StClipboardClass))
-
-#define ST_IS_CLIPBOARD(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
- ST_TYPE_CLIPBOARD))
-
-#define ST_IS_CLIPBOARD_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), \
- ST_TYPE_CLIPBOARD))
-
-#define ST_CLIPBOARD_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), \
- ST_TYPE_CLIPBOARD, StClipboardClass))
+G_DECLARE_FINAL_TYPE (StClipboard, st_clipboard, ST, CLIPBOARD, GObject)
typedef struct _StClipboard StClipboard;
-typedef struct _StClipboardClass StClipboardClass;
typedef struct _StClipboardPrivate StClipboardPrivate;
/**
StClipboardPrivate *priv;
};
-struct _StClipboardClass
-{
- GObjectClass parent_class;
-};
-
typedef enum {
ST_CLIPBOARD_TYPE_PRIMARY,
ST_CLIPBOARD_TYPE_CLIPBOARD
const gchar *text,
gpointer user_data);
-GType st_clipboard_get_type (void);
-
StClipboard* st_clipboard_get_default (void);
void st_clipboard_get_text (StClipboard *clipboard,
#include <cairo.h>
+typedef struct _StDrawingAreaPrivate StDrawingAreaPrivate;
struct _StDrawingAreaPrivate {
CoglTexture *texture;
CoglPipeline *pipeline;
st_drawing_area_dispose (GObject *object)
{
StDrawingArea *area = ST_DRAWING_AREA (object);
- StDrawingAreaPrivate *priv = area->priv;
+ StDrawingAreaPrivate *priv = st_drawing_area_get_instance_private (area);
g_clear_pointer (&priv->pipeline, cogl_object_unref);
g_clear_pointer (&priv->texture, cogl_object_unref);
st_drawing_area_paint (ClutterActor *self)
{
StDrawingArea *area = ST_DRAWING_AREA (self);
- StDrawingAreaPrivate *priv = area->priv;
+ StDrawingAreaPrivate *priv = st_drawing_area_get_instance_private (area);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
ClutterActorBox allocation_box;
ClutterActorBox content_box;
st_drawing_area_style_changed (StWidget *self)
{
StDrawingArea *area = ST_DRAWING_AREA (self);
- StDrawingAreaPrivate *priv = area->priv;
+ StDrawingAreaPrivate *priv = st_drawing_area_get_instance_private (area);
(ST_WIDGET_CLASS (st_drawing_area_parent_class))->style_changed (self);
static void
st_drawing_area_init (StDrawingArea *area)
{
- area->priv = st_drawing_area_get_instance_private (area);
- area->priv->texture = NULL;
+ StDrawingAreaPrivate *priv = st_drawing_area_get_instance_private (area);
+ priv->texture = NULL;
}
/**
g_return_if_fail (ST_IS_DRAWING_AREA (area));
- priv = area->priv;
+ priv = st_drawing_area_get_instance_private (area);
priv->needs_repaint = TRUE;
clutter_actor_queue_redraw (CLUTTER_ACTOR (area));
cairo_t *
st_drawing_area_get_context (StDrawingArea *area)
{
+ StDrawingAreaPrivate *priv;
+
g_return_val_if_fail (ST_IS_DRAWING_AREA (area), NULL);
- g_return_val_if_fail (area->priv->in_repaint, NULL);
- return area->priv->context;
+ priv = st_drawing_area_get_instance_private (area);
+ g_return_val_if_fail (priv->in_repaint, NULL);
+
+ return priv->context;
}
/**
StDrawingAreaPrivate *priv;
g_return_if_fail (ST_IS_DRAWING_AREA (area));
- g_return_if_fail (area->priv->in_repaint);
- priv = area->priv;
+ priv = st_drawing_area_get_instance_private (area);
+ g_return_if_fail (priv->in_repaint);
if (width)
*width = cogl_texture_get_width (priv->texture);
#include "st-widget.h"
#include <cairo.h>
-#define ST_TYPE_DRAWING_AREA (st_drawing_area_get_type ())
-#define ST_DRAWING_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_DRAWING_AREA, StDrawingArea))
-#define ST_DRAWING_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_DRAWING_AREA, StDrawingAreaClass))
-#define ST_IS_DRAWING_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_DRAWING_AREA))
-#define ST_IS_DRAWING_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_DRAWING_AREA))
-#define ST_DRAWING_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_DRAWING_AREA, StDrawingAreaClass))
-
-typedef struct _StDrawingArea StDrawingArea;
-typedef struct _StDrawingAreaClass StDrawingAreaClass;
-
-typedef struct _StDrawingAreaPrivate StDrawingAreaPrivate;
-
-struct _StDrawingArea
-{
- StWidget parent;
-
- StDrawingAreaPrivate *priv;
-};
+#define ST_TYPE_DRAWING_AREA (st_drawing_area_get_type ())
+G_DECLARE_DERIVABLE_TYPE (StDrawingArea, st_drawing_area,
+ ST, DRAWING_AREA, StWidget)
struct _StDrawingAreaClass
{
void (*repaint) (StDrawingArea *area);
};
-GType st_drawing_area_get_type (void) G_GNUC_CONST;
-
void st_drawing_area_queue_repaint (StDrawingArea *area);
cairo_t *st_drawing_area_get_context (StDrawingArea *area);
void st_drawing_area_get_surface_size (StDrawingArea *area,
LAST_SIGNAL
};
-#define ST_ENTRY_PRIV(x) ((StEntry *) x)->priv
+#define ST_ENTRY_PRIV(x) st_entry_get_instance_private ((StEntry *) x)
+typedef struct _StEntryPrivate StEntryPrivate;
struct _StEntryPrivate
{
ClutterActor *entry;
static void
show_capslock_feedback (StEntry *entry)
{
- if (entry->priv->secondary_icon == NULL)
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
+ if (priv->secondary_icon == NULL)
{
ClutterActor *icon = g_object_new (ST_TYPE_ICON,
"style-class", "capslock-warning",
NULL);
st_entry_set_secondary_icon (entry, icon);
- entry->priv->capslock_warning_shown = TRUE;
+ priv->capslock_warning_shown = TRUE;
}
}
static void
remove_capslock_feedback (StEntry *entry)
{
- if (entry->priv->capslock_warning_shown)
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
+ if (priv->capslock_warning_shown)
{
st_entry_set_secondary_icon (entry, NULL);
- entry->priv->capslock_warning_shown = FALSE;
+ priv->capslock_warning_shown = FALSE;
}
}
gpointer user_data)
{
StEntry *entry = ST_ENTRY (user_data);
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
- if (clutter_text_get_password_char (CLUTTER_TEXT (entry->priv->entry)) != 0)
+ if (clutter_text_get_password_char (CLUTTER_TEXT (priv->entry)) != 0)
{
if (gdk_keymap_get_caps_lock_state (keymap))
show_capslock_feedback (entry);
st_entry_dispose (GObject *object)
{
StEntry *entry = ST_ENTRY (object);
- StEntryPrivate *priv = entry->priv;
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
GdkKeymap *keymap;
if (priv->entry)
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
- StEntryPrivate *priv = entry->priv;
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
GdkKeymap *keymap;
/* remove the hint if visible */
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
- StEntryPrivate *priv = entry->priv;
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
GdkKeymap *keymap;
st_widget_remove_style_pseudo_class (ST_WIDGET (actor), "focus");
gpointer user_data)
{
StEntry *entry = ST_ENTRY (user_data);
+ StEntryPrivate *priv = ST_ENTRY_PRIV (entry);
- if (clutter_text_get_password_char (CLUTTER_TEXT (entry->priv->entry)) == 0)
+ if (clutter_text_get_password_char (CLUTTER_TEXT (priv->entry)) == 0)
remove_capslock_feedback (entry);
}
const gchar *text,
gpointer data)
{
- ClutterText *ctext = (ClutterText*)((StEntry *) data)->priv->entry;
+ StEntryPrivate *priv = ST_ENTRY_PRIV (data);
+ ClutterText *ctext = (ClutterText*)priv->entry;
gint cursor_pos;
if (!text)
{
cursor_func (entry, use_ibeam, cursor_func_data);
- entry->priv->has_ibeam = use_ibeam;
+ ((StEntryPrivate *)ST_ENTRY_PRIV (entry))->has_ibeam = use_ibeam;
}
static gboolean
st_entry_enter_event (ClutterActor *actor,
ClutterCrossingEvent *event)
{
- if (event->source == ST_ENTRY (actor)->priv->entry && event->related != NULL)
+ StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+ if (event->source == priv->entry && event->related != NULL)
st_entry_set_cursor (ST_ENTRY (actor), TRUE);
return CLUTTER_ACTOR_CLASS (st_entry_parent_class)->enter_event (actor, event);
st_entry_leave_event (ClutterActor *actor,
ClutterCrossingEvent *event)
{
- if (event->source == ST_ENTRY (actor)->priv->entry && event->related != NULL)
+ StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+ if (event->source == priv->entry && event->related != NULL)
st_entry_set_cursor (ST_ENTRY (actor), FALSE);
return CLUTTER_ACTOR_CLASS (st_entry_parent_class)->leave_event (actor, event);
static void
st_entry_unmap (ClutterActor *actor)
{
- if (ST_ENTRY (actor)->priv->has_ibeam)
+ StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+ if (priv->has_ibeam)
st_entry_set_cursor (ST_ENTRY (actor), FALSE);
CLUTTER_ACTOR_CLASS (st_entry_parent_class)->unmap (actor);
{
StEntryPrivate *priv;
- priv = entry->priv = st_entry_get_instance_private (entry);
+ priv = st_entry_get_instance_private (entry);
priv->entry = g_object_new (ST_TYPE_IM_TEXT,
"line-alignment", PANGO_ALIGN_LEFT,
const gchar *
st_entry_get_text (StEntry *entry)
{
+ StEntryPrivate *priv;
+
g_return_val_if_fail (ST_IS_ENTRY (entry), NULL);
- if (entry->priv->hint_visible)
+ priv = st_entry_get_instance_private (entry);
+ if (priv->hint_visible)
return "";
else
- return clutter_text_get_text (CLUTTER_TEXT (entry->priv->entry));
+ return clutter_text_get_text (CLUTTER_TEXT (priv->entry));
}
/**
g_return_if_fail (ST_IS_ENTRY (entry));
- priv = entry->priv;
+ priv = st_entry_get_instance_private (entry);
/* set a hint if we are blanking the entry */
if (priv->hint
{
g_return_val_if_fail (ST_ENTRY (entry), NULL);
- return entry->priv->entry;
+ return ((StEntryPrivate *)ST_ENTRY_PRIV (entry))->entry;
}
/**
g_return_if_fail (ST_IS_ENTRY (entry));
- priv = entry->priv;
+ priv = st_entry_get_instance_private (entry);
g_free (priv->hint);
{
g_return_val_if_fail (ST_IS_ENTRY (entry), NULL);
- return entry->priv->hint;
+ return ((StEntryPrivate *)ST_ENTRY_PRIV (entry))->hint;
}
/**
st_entry_set_input_purpose (StEntry *entry,
GtkInputPurpose purpose)
{
+ StEntryPrivate *priv;
StIMText *imtext;
g_return_if_fail (ST_IS_ENTRY (entry));
- imtext = ST_IM_TEXT (entry->priv->entry);
+ priv = st_entry_get_instance_private (entry);
+ imtext = ST_IM_TEXT (priv->entry);
if (st_im_text_get_input_purpose (imtext) != purpose)
{
GtkInputPurpose
st_entry_get_input_purpose (StEntry *entry)
{
+ StEntryPrivate *priv;
+
g_return_val_if_fail (ST_IS_ENTRY (entry), GTK_INPUT_PURPOSE_FREE_FORM);
- return st_im_text_get_input_purpose (ST_IM_TEXT (entry->priv->entry));
+ priv = st_entry_get_instance_private (entry);
+ return st_im_text_get_input_purpose (ST_IM_TEXT (priv->entry));
}
/**
st_entry_set_input_hints (StEntry *entry,
GtkInputHints hints)
{
+ StEntryPrivate *priv;
StIMText *imtext;
g_return_if_fail (ST_IS_ENTRY (entry));
- imtext = ST_IM_TEXT (entry->priv->entry);
+ priv = st_entry_get_instance_private (entry);
+ imtext = ST_IM_TEXT (priv->entry);
if (st_im_text_get_input_hints (imtext) != hints)
{
GtkInputHints
st_entry_get_input_hints (StEntry *entry)
{
+ StEntryPrivate *priv;
+
g_return_val_if_fail (ST_IS_ENTRY (entry), GTK_INPUT_HINT_NONE);
- return st_im_text_get_input_hints (ST_IM_TEXT (entry->priv->entry));
+ priv = st_entry_get_instance_private (entry);
+ return st_im_text_get_input_hints (ST_IM_TEXT (priv->entry));
}
static gboolean
ClutterButtonEvent *event,
StEntry *entry)
{
- StEntryPrivate *priv = entry->priv;
+ StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
if (actor == priv->primary_icon)
g_signal_emit (entry, entry_signals[PRIMARY_ICON_CLICKED], 0);
g_return_if_fail (ST_IS_ENTRY (entry));
- priv = entry->priv;
+ priv = st_entry_get_instance_private (entry);
_st_entry_set_icon (entry, &priv->primary_icon, icon);
}
g_return_if_fail (ST_IS_ENTRY (entry));
- priv = entry->priv;
+ priv = st_entry_get_instance_private (entry);
_st_entry_set_icon (entry, &priv->secondary_icon, icon);
}
st_entry_accessible_get_n_children (AtkObject *obj)
{
StEntry *entry = NULL;
+ StEntryPrivate *priv;
g_return_val_if_fail (ST_IS_ENTRY_ACCESSIBLE (obj), 0);
if (entry == NULL)
return 0;
- if (entry->priv->entry == NULL)
+ priv = st_entry_get_instance_private (entry);
+ if (priv->entry == NULL)
return 0;
else
return 1;
gint i)
{
StEntry *entry = NULL;
+ StEntryPrivate *priv;
AtkObject *result = NULL;
g_return_val_if_fail (ST_IS_ENTRY_ACCESSIBLE (obj), NULL);
if (entry == NULL)
return NULL;
- if (entry->priv->entry == NULL)
+ priv = st_entry_get_instance_private (entry);
+ if (priv->entry == NULL)
return NULL;
- result = clutter_actor_get_accessible (entry->priv->entry);
+ result = clutter_actor_get_accessible (priv->entry);
g_object_ref (result);
return result;
#include <st/st-widget.h>
-#define ST_TYPE_ENTRY (st_entry_get_type ())
-#define ST_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_ENTRY, StEntry))
-#define ST_IS_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_ENTRY))
-#define ST_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_ENTRY, StEntryClass))
-#define ST_IS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_ENTRY))
-#define ST_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_ENTRY, StEntryClass))
-
-typedef struct _StEntry StEntry;
-typedef struct _StEntryPrivate StEntryPrivate;
-typedef struct _StEntryClass StEntryClass;
-
-/**
- * StEntry:
- *
- * The contents of this structure is private and should only be accessed using
- * the provided API.
- */
-struct _StEntry
-{
- /*< private >*/
- StWidget parent_instance;
-
- StEntryPrivate *priv;
-};
+#define ST_TYPE_ENTRY (st_entry_get_type ())
+G_DECLARE_DERIVABLE_TYPE (StEntry, st_entry, ST, ENTRY, StWidget)
struct _StEntryClass
{
void (*secondary_icon_clicked) (StEntry *entry);
};
-GType st_entry_get_type (void) G_GNUC_CONST;
-
StWidget *st_entry_new (const gchar *text);
const gchar *st_entry_get_text (StEntry *entry);
void st_entry_set_text (StEntry *entry,
G_BEGIN_DECLS
#define ST_TYPE_FOCUS_MANAGER (st_focus_manager_get_type ())
-#define ST_FOCUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_FOCUS_MANAGER, StFocusManager))
-#define ST_IS_FOCUS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_FOCUS_MANAGER))
-#define ST_FOCUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_FOCUS_MANAGER, StFocusManagerClass))
-#define ST_IS_FOCUS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_FOCUS_MANAGER))
-#define ST_FOCUS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_FOCUS_MANAGER, StFocusManagerClass))
+G_DECLARE_FINAL_TYPE (StFocusManager, st_focus_manager, ST, FOCUS_MANAGER, GObject)
typedef struct _StFocusManager StFocusManager;
typedef struct _StFocusManagerPrivate StFocusManagerPrivate;
-typedef struct _StFocusManagerClass StFocusManagerClass;
/**
* StFocusManager:
StFocusManagerPrivate *priv;
};
-/**
- * StFocusManagerClass:
- *
- * The #StFocusManagerClass struct contains only private data
- */
-struct _StFocusManagerClass
-{
- /*< private >*/
- GObjectClass parent_class;
-};
-
-GType st_focus_manager_get_type (void) G_GNUC_CONST;
-
StFocusManager *st_focus_manager_get_for_stage (ClutterStage *stage);
void st_focus_manager_add_group (StFocusManager *manager,
G_BEGIN_DECLS
#define ST_TYPE_ICON st_icon_get_type()
-
-#define ST_ICON(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_ICON, StIcon))
-
-#define ST_ICON_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_ICON, StIconClass))
-
-#define ST_IS_ICON(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_ICON))
-
-#define ST_IS_ICON_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_ICON))
-
-#define ST_ICON_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_ICON, StIconClass))
+G_DECLARE_FINAL_TYPE (StIcon, st_icon, ST, ICON, StWidget)
typedef struct _StIconPrivate StIconPrivate;
* The contents of this structure are private and should only be accessed
* through the public API.
*/
-typedef struct {
+struct _StIcon {
/*< private >*/
StWidget parent;
StIconPrivate *priv;
-} StIcon;
-
-typedef struct {
- StWidgetClass parent_class;
-
- /* padding for future expansion */
- void (*_padding_0) (void);
- void (*_padding_1) (void);
- void (*_padding_2) (void);
- void (*_padding_3) (void);
- void (*_padding_4) (void);
-} StIconClass;
-
-GType st_icon_get_type (void);
+};
ClutterActor* st_icon_new (void);
#include <clutter/clutter.h>
#define ST_TYPE_IM_TEXT (st_im_text_get_type ())
-#define ST_IM_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_IM_TEXT, StIMText))
-#define ST_IS_IM_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_IM_TEXT))
-#define ST_IM_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_IM_TEXT, StIMTextClass))
-#define ST_IS_IM_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_IM_TEXT))
-#define ST_IM_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_IM_TEXT, StIMTextClass))
+G_DECLARE_FINAL_TYPE (StIMText, st_im_text, ST, IM_TEXT, ClutterText)
typedef struct _StIMText StIMText;
typedef struct _StIMTextPrivate StIMTextPrivate;
-typedef struct _StIMTextClass StIMTextClass;
struct _StIMText
{
StIMTextPrivate *priv;
};
-struct _StIMTextClass
-{
- ClutterTextClass parent_class;
-};
-
-GType st_im_text_get_type (void) G_GNUC_CONST;
-
ClutterActor *st_im_text_new (const gchar *text);
void st_im_text_set_input_purpose (StIMText *imtext,
GtkInputPurpose purpose);
#include <st/st-widget.h>
#define ST_TYPE_LABEL (st_label_get_type ())
-#define ST_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_LABEL, StLabel))
-#define ST_IS_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_LABEL))
-#define ST_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_LABEL, StLabelClass))
-#define ST_IS_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_LABEL))
-#define ST_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_LABEL, StLabelClass))
+G_DECLARE_FINAL_TYPE (StLabel, st_label, ST, LABEL, StWidget)
-typedef struct _StLabel StLabel;
typedef struct _StLabelPrivate StLabelPrivate;
-typedef struct _StLabelClass StLabelClass;
/**
* StLabel:
StLabelPrivate *priv;
};
-struct _StLabelClass
-{
- StWidgetClass parent_class;
-};
-
-GType st_label_get_type (void) G_GNUC_CONST;
-
StWidget * st_label_new (const gchar *text);
const gchar * st_label_get_text (StLabel *label);
void st_label_set_text (StLabel *label,
#define PAGING_INITIAL_REPEAT_TIMEOUT 500
#define PAGING_SUBSEQUENT_REPEAT_TIMEOUT 200
+typedef struct _StScrollBarPrivate StScrollBarPrivate;
struct _StScrollBarPrivate
{
StAdjustment *adjustment;
G_DEFINE_TYPE_WITH_PRIVATE (StScrollBar, st_scroll_bar, ST_TYPE_WIDGET)
+#define ST_SCROLL_BAR_PRIVATE(sb) st_scroll_bar_get_instance_private (ST_SCROLL_BAR (sb))
+
enum
{
PROP_0,
GValue *value,
GParamSpec *pspec)
{
- StScrollBarPrivate *priv = ST_SCROLL_BAR (gobject)->priv;
+ StScrollBarPrivate *priv = ST_SCROLL_BAR_PRIVATE (gobject);
switch (prop_id)
{
GParamSpec *pspec)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
switch (prop_id)
{
break;
case PROP_VERTICAL:
- bar->priv->vertical = g_value_get_boolean (value);
- if (bar->priv->vertical)
- clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle),
+ priv->vertical = g_value_get_boolean (value);
+ if (priv->vertical)
+ clutter_actor_set_name (CLUTTER_ACTOR (priv->handle),
"vhandle");
else
- clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle),
+ clutter_actor_set_name (CLUTTER_ACTOR (priv->handle),
"hhandle");
clutter_actor_queue_relayout ((ClutterActor*) gobject);
break;
st_scroll_bar_dispose (GObject *gobject)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
if (priv->adjustment)
st_scroll_bar_set_adjustment (bar, NULL);
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (bar));
ClutterActorBox content_box, trough_box;
gfloat *natural_width_p)
{
StScrollBar *bar = ST_SCROLL_BAR (self);
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gfloat trough_min_width, trough_natural_width;
gfloat handle_min_width, handle_natural_width;
gfloat *natural_height_p)
{
StScrollBar *bar = ST_SCROLL_BAR (self);
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gfloat trough_min_height, trough_natural_height;
gfloat handle_min_height, handle_natural_height;
static void
st_scroll_bar_style_changed (StWidget *widget)
{
- StScrollBarPrivate *priv = ST_SCROLL_BAR (widget)->priv;
+ StScrollBarPrivate *priv = ST_SCROLL_BAR_PRIVATE (widget);
st_widget_style_changed (ST_WIDGET (priv->trough));
st_widget_style_changed (ST_WIDGET (priv->handle));
gpointer user_data)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
- clutter_actor_set_reactive (bar->priv->handle,
+ clutter_actor_set_reactive (priv->handle,
clutter_actor_get_reactive (CLUTTER_ACTOR (bar)));
}
st_scroll_bar_scroll_event (ClutterActor *actor,
ClutterScrollEvent *event)
{
- StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
+ StScrollBarPrivate *priv = ST_SCROLL_BAR_PRIVATE (actor);
if (clutter_event_is_pointer_emulated ((ClutterEvent *) event))
return TRUE;
gfloat x,
gfloat y)
{
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
gdouble position, lower, upper, page_size;
gfloat ux, uy, pos, size;
static void
stop_scrolling (StScrollBar *bar)
{
- if (!bar->priv->grabbed)
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
+ if (!priv->grabbed)
return;
- st_widget_remove_style_pseudo_class (ST_WIDGET (bar->priv->handle), "active");
+ st_widget_remove_style_pseudo_class (ST_WIDGET (priv->handle), "active");
clutter_ungrab_pointer ();
- bar->priv->grabbed = FALSE;
+ priv->grabbed = FALSE;
g_signal_emit (bar, signals[SCROLL_STOP], 0);
}
ClutterMotionEvent *event,
StScrollBar *bar)
{
- if (!bar->priv->grabbed)
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
+ if (!priv->grabbed)
return FALSE;
move_slider (bar, event->x, event->y);
ClutterButtonEvent *event,
StScrollBar *bar)
{
- StScrollBarPrivate *priv = bar->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (bar);
if (event->button != 1)
return FALSE;
static gboolean
trough_paging_cb (StScrollBar *self)
{
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (self);
gfloat handle_pos, event_pos, tx, ty;
gdouble value;
gdouble page_increment;
GValue v = { 0, };
ClutterTimeline *t;
- if (self->priv->paging_event_no == 0)
+ if (priv->paging_event_no == 0)
{
/* Scroll on after initial timeout. */
mode = CLUTTER_EASE_OUT_CUBIC;
ret = FALSE;
- self->priv->paging_event_no = 1;
- self->priv->paging_source_id = g_timeout_add (
+ priv->paging_event_no = 1;
+ priv->paging_source_id = g_timeout_add (
PAGING_INITIAL_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
- g_source_set_name_by_id (self->priv->paging_source_id, "[gnome-shell] trough_paging_cb");
+ g_source_set_name_by_id (priv->paging_source_id, "[gnome-shell] trough_paging_cb");
}
- else if (self->priv->paging_event_no == 1)
+ else if (priv->paging_event_no == 1)
{
/* Scroll on after subsequent timeout. */
ret = FALSE;
mode = CLUTTER_EASE_IN_CUBIC;
- self->priv->paging_event_no = 2;
- self->priv->paging_source_id = g_timeout_add (
+ priv->paging_event_no = 2;
+ priv->paging_source_id = g_timeout_add (
PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
- g_source_set_name_by_id (self->priv->paging_source_id, "[gnome-shell] trough_paging_cb");
+ g_source_set_name_by_id (priv->paging_source_id, "[gnome-shell] trough_paging_cb");
}
else
{
/* Keep scrolling. */
ret = TRUE;
mode = CLUTTER_LINEAR;
- self->priv->paging_event_no++;
+ priv->paging_event_no++;
}
/* Do the scrolling */
- st_adjustment_get_values (self->priv->adjustment,
+ st_adjustment_get_values (priv->adjustment,
&value, NULL, NULL,
NULL, &page_increment, NULL);
- if (self->priv->vertical)
- handle_pos = clutter_actor_get_y (self->priv->handle);
+ if (priv->vertical)
+ handle_pos = clutter_actor_get_y (priv->handle);
else
- handle_pos = clutter_actor_get_x (self->priv->handle);
+ handle_pos = clutter_actor_get_x (priv->handle);
- clutter_actor_transform_stage_point (CLUTTER_ACTOR (self->priv->trough),
- self->priv->move_x,
- self->priv->move_y,
+ clutter_actor_transform_stage_point (CLUTTER_ACTOR (priv->trough),
+ priv->move_x,
+ priv->move_y,
&tx, &ty);
- if (self->priv->vertical)
+ if (priv->vertical)
event_pos = ty;
else
event_pos = tx;
if (event_pos > handle_pos)
{
- if (self->priv->paging_direction == NONE)
+ if (priv->paging_direction == NONE)
{
/* Remember direction. */
- self->priv->paging_direction = DOWN;
+ priv->paging_direction = DOWN;
}
- if (self->priv->paging_direction == UP)
+ if (priv->paging_direction == UP)
{
/* Scrolled far enough. */
return FALSE;
}
else
{
- if (self->priv->paging_direction == NONE)
+ if (priv->paging_direction == NONE)
{
/* Remember direction. */
- self->priv->paging_direction = UP;
+ priv->paging_direction = UP;
}
- if (self->priv->paging_direction == DOWN)
+ if (priv->paging_direction == DOWN)
{
/* Scrolled far enough. */
return FALSE;
value -= page_increment;
}
- if (self->priv->paging_animation)
+ if (priv->paging_animation)
{
- clutter_animation_completed (self->priv->paging_animation);
+ clutter_animation_completed (priv->paging_animation);
}
/* FIXME: Creating a new animation for each scroll is probably not the best
* idea, but it's a lot less involved than extenind the current animation */
- a = self->priv->paging_animation = g_object_new (CLUTTER_TYPE_ANIMATION,
- "object", self->priv->adjustment,
+ a = priv->paging_animation = g_object_new (CLUTTER_TYPE_ANIMATION,
+ "object", priv->adjustment,
"duration", (guint)(PAGING_SUBSEQUENT_REPEAT_TIMEOUT * st_slow_down_factor),
"mode", mode,
NULL);
g_value_init (&v, G_TYPE_DOUBLE);
g_value_set_double (&v, value);
- clutter_animation_bind (self->priv->paging_animation, "value", &v);
- t = clutter_animation_get_timeline (self->priv->paging_animation);
- g_signal_connect (a, "completed", G_CALLBACK (animation_completed_cb),
- self->priv);
+ clutter_animation_bind (priv->paging_animation, "value", &v);
+ t = clutter_animation_get_timeline (priv->paging_animation);
+ g_signal_connect (a, "completed", G_CALLBACK (animation_completed_cb), priv);
clutter_timeline_start (t);
return ret;
ClutterButtonEvent *event,
StScrollBar *self)
{
+ StScrollBarPrivate *priv;
+
g_return_val_if_fail (self, FALSE);
if (event->button != 1)
return FALSE;
- if (self->priv->adjustment == NULL)
+ priv = st_scroll_bar_get_instance_private (self);
+ if (priv->adjustment == NULL)
return FALSE;
- self->priv->move_x = event->x;
- self->priv->move_y = event->y;
- self->priv->paging_direction = NONE;
- self->priv->paging_event_no = 0;
+ priv->move_x = event->x;
+ priv->move_y = event->y;
+ priv->paging_direction = NONE;
+ priv->paging_event_no = 0;
trough_paging_cb (self);
return TRUE;
ClutterButtonEvent *event,
StScrollBar *self)
{
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (self);
+
if (event->button != 1)
return FALSE;
- if (self->priv->paging_source_id)
+ if (priv->paging_source_id)
{
- g_source_remove (self->priv->paging_source_id);
- self->priv->paging_source_id = 0;
+ g_source_remove (priv->paging_source_id);
+ priv->paging_source_id = 0;
}
return TRUE;
ClutterEvent *event,
StScrollBar *self)
{
- if (self->priv->paging_source_id)
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (self);
+
+ if (priv->paging_source_id)
{
- g_source_remove (self->priv->paging_source_id);
- self->priv->paging_source_id = 0;
+ g_source_remove (priv->paging_source_id);
+ priv->paging_source_id = 0;
return TRUE;
}
static void
st_scroll_bar_notify_reactive (StScrollBar *self)
{
- StScrollBarPrivate *priv = self->priv;
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (self);
gboolean reactive = clutter_actor_get_reactive (CLUTTER_ACTOR (self));
static void
st_scroll_bar_init (StScrollBar *self)
{
- self->priv = st_scroll_bar_get_instance_private (self);
+ StScrollBarPrivate *priv = st_scroll_bar_get_instance_private (self);
- self->priv->trough = (ClutterActor *) st_bin_new ();
- clutter_actor_set_reactive ((ClutterActor *) self->priv->trough, TRUE);
- clutter_actor_set_name (CLUTTER_ACTOR (self->priv->trough), "trough");
+ priv->trough = (ClutterActor *) st_bin_new ();
+ clutter_actor_set_reactive ((ClutterActor *) priv->trough, TRUE);
+ clutter_actor_set_name (CLUTTER_ACTOR (priv->trough), "trough");
clutter_actor_add_child (CLUTTER_ACTOR (self),
- CLUTTER_ACTOR (self->priv->trough));
- g_signal_connect (self->priv->trough, "button-press-event",
+ CLUTTER_ACTOR (priv->trough));
+ g_signal_connect (priv->trough, "button-press-event",
G_CALLBACK (trough_button_press_event_cb), self);
- g_signal_connect (self->priv->trough, "button-release-event",
+ g_signal_connect (priv->trough, "button-release-event",
G_CALLBACK (trough_button_release_event_cb), self);
- g_signal_connect (self->priv->trough, "leave-event",
+ g_signal_connect (priv->trough, "leave-event",
G_CALLBACK (trough_leave_event_cb), self);
- self->priv->handle = (ClutterActor *) st_button_new ();
- clutter_actor_set_name (CLUTTER_ACTOR (self->priv->handle), "hhandle");
+ priv->handle = (ClutterActor *) st_button_new ();
+ clutter_actor_set_name (CLUTTER_ACTOR (priv->handle), "hhandle");
clutter_actor_add_child (CLUTTER_ACTOR (self),
- CLUTTER_ACTOR (self->priv->handle));
- g_signal_connect (self->priv->handle, "button-press-event",
+ CLUTTER_ACTOR (priv->handle));
+ g_signal_connect (priv->handle, "button-press-event",
G_CALLBACK (handle_button_press_event_cb), self);
- g_signal_connect (self->priv->handle, "button-release-event",
+ g_signal_connect (priv->handle, "button-release-event",
G_CALLBACK (handle_button_release_event_cb), self);
- g_signal_connect (self->priv->handle, "motion-event",
+ g_signal_connect (priv->handle, "motion-event",
G_CALLBACK (handle_motion_event_cb), self);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
g_return_if_fail (ST_IS_SCROLL_BAR (bar));
- priv = bar->priv;
+ priv = st_scroll_bar_get_instance_private (bar);
if (adjustment == priv->adjustment)
return;
{
g_return_val_if_fail (ST_IS_SCROLL_BAR (bar), NULL);
- return bar->priv->adjustment;
+ return ((StScrollBarPrivate *)ST_SCROLL_BAR_PRIVATE (bar))->adjustment;
}
G_BEGIN_DECLS
-#define ST_TYPE_SCROLL_BAR (st_scroll_bar_get_type())
-#define ST_SCROLL_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLL_BAR, StScrollBar))
-#define ST_IS_SCROLL_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLL_BAR))
-#define ST_SCROLL_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SCROLL_BAR, StScrollBarClass))
-#define ST_IS_SCROLL_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SCROLL_BAR))
-#define ST_SCROLL_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SCROLL_BAR, StScrollBarClass))
-
-typedef struct _StScrollBar StScrollBar;
-typedef struct _StScrollBarPrivate StScrollBarPrivate;
-typedef struct _StScrollBarClass StScrollBarClass;
-
-/**
- * StScrollBar:
- *
- * The contents of this structure are private and should only be accessed
- * through the public API.
- */
-struct _StScrollBar
-{
- /*< private >*/
- StWidget parent_instance;
-
- StScrollBarPrivate *priv;
-};
+#define ST_TYPE_SCROLL_BAR (st_scroll_bar_get_type())
+G_DECLARE_DERIVABLE_TYPE (StScrollBar, st_scroll_bar, ST, SCROLL_BAR, StWidget)
struct _StScrollBarClass
{
void (*scroll_stop) (StScrollBar *bar);
};
-GType st_scroll_bar_get_type (void) G_GNUC_CONST;
-
StWidget *st_scroll_bar_new (StAdjustment *adjustment);
void st_scroll_bar_set_adjustment (StScrollBar *bar,
*/
-#define ST_SCROLL_VIEW_FADE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SCROLL_VIEW_FADE, StScrollViewFadeClass))
-#define ST_IS_SCROLL_VIEW_FADE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SCROLL_VIEW_FADE))
-#define ST_SCROLL_VIEW_FADE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SCROLL_VIEW_FADE, StScrollViewFadeClass))
-
#include "st-scroll-view-fade.h"
#include "st-scroll-view.h"
#include "st-widget.h"
#include <clutter/clutter.h>
#include <cogl/cogl.h>
-typedef struct _StScrollViewFadeClass StScrollViewFadeClass;
-
#define DEFAULT_FADE_OFFSET 68.0f
#include "st-scroll-view-fade-generated.c"
float hfade_offset;
};
-struct _StScrollViewFadeClass
-{
- ClutterShaderEffectClass parent_class;
-};
-
G_DEFINE_TYPE (StScrollViewFade,
st_scroll_view_fade,
CLUTTER_TYPE_SHADER_EFFECT);
G_BEGIN_DECLS
#define ST_TYPE_SCROLL_VIEW_FADE (st_scroll_view_fade_get_type ())
-#define ST_SCROLL_VIEW_FADE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLL_VIEW_FADE, StScrollViewFade))
-#define ST_IS_SCROLL_VIEW_FADE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLL_VIEW_FADE))
-
-typedef struct _StScrollViewFade StScrollViewFade;
-
-GType st_scroll_view_fade_get_type (void) G_GNUC_CONST;
+G_DECLARE_FINAL_TYPE (StScrollViewFade, st_scroll_view_fade,
+ ST, SCROLL_VIEW_FADE, ClutterShaderEffect)
ClutterEffect *st_scroll_view_fade_new (void);
G_BEGIN_DECLS
#define ST_TYPE_SCROLL_VIEW (st_scroll_view_get_type())
-#define ST_SCROLL_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLL_VIEW, StScrollView))
-#define ST_IS_SCROLL_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLL_VIEW))
-#define ST_SCROLL_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SCROLL_VIEW, StScrollViewClass))
-#define ST_IS_SCROLL_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SCROLL_VIEW))
-#define ST_SCROLL_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SCROLL_VIEW, StScrollViewClass))
+G_DECLARE_FINAL_TYPE (StScrollView, st_scroll_view, ST, SCROLL_VIEW, StBin)
-typedef struct _StScrollView StScrollView;
typedef struct _StScrollViewPrivate StScrollViewPrivate;
-typedef struct _StScrollViewClass StScrollViewClass;
/**
* StScrollView:
StScrollViewPrivate *priv;
};
-struct _StScrollViewClass
-{
- StBinClass parent_class;
-};
-
-GType st_scroll_view_get_type (void) G_GNUC_CONST;
-
StWidget *st_scroll_view_new (void);
ClutterActor *st_scroll_view_get_hscroll_bar (StScrollView *scroll);
#include "st-scrollable.h"
+G_DEFINE_INTERFACE (StScrollable, st_scrollable, G_TYPE_OBJECT)
+
/**
* SECTION:st-scrollable
* @short_description: A #ClutterActor that can be scrolled
* page_increment: page_size - step_increment
*/
static void
-st_scrollable_base_init (gpointer g_iface)
+st_scrollable_default_init (StScrollableInterface *g_iface)
{
static gboolean initialized = FALSE;
}
}
-GType
-st_scrollable_get_type (void)
-{
- static GType type = 0;
- if (type == 0)
- {
- static const GTypeInfo info =
- {
- sizeof (StScrollableInterface),
- st_scrollable_base_init, /* base_init */
- NULL,
- };
- type = g_type_register_static (G_TYPE_INTERFACE,
- "StScrollable", &info, 0);
- }
- return type;
-}
-
void
st_scrollable_set_adjustments (StScrollable *scrollable,
StAdjustment *hadjustment,
StAdjustment *vadjustment)
{
- ST_SCROLLABLE_GET_INTERFACE (scrollable)->set_adjustments (scrollable,
- hadjustment,
- vadjustment);
+ ST_SCROLLABLE_GET_IFACE (scrollable)->set_adjustments (scrollable,
+ hadjustment,
+ vadjustment);
}
/**
StAdjustment **hadjustment,
StAdjustment **vadjustment)
{
- ST_SCROLLABLE_GET_INTERFACE (scrollable)->get_adjustments (scrollable,
- hadjustment,
- vadjustment);
+ ST_SCROLLABLE_GET_IFACE (scrollable)->get_adjustments (scrollable,
+ hadjustment,
+ vadjustment);
}
G_BEGIN_DECLS
#define ST_TYPE_SCROLLABLE (st_scrollable_get_type ())
-#define ST_SCROLLABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLLABLE, StScrollable))
-#define ST_IS_SCROLLABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLLABLE))
-#define ST_SCROLLABLE_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), ST_TYPE_SCROLLABLE, StScrollableInterface))
+G_DECLARE_INTERFACE (StScrollable, st_scrollable, ST, SCROLLABLE, GObject)
-typedef struct _StScrollable StScrollable; /* Dummy object */
typedef struct _StScrollableInterface StScrollableInterface;
struct _StScrollableInterface
StAdjustment **vadjustment);
};
-GType st_scrollable_get_type (void) G_GNUC_CONST;
-
void st_scrollable_set_adjustments (StScrollable *scrollable,
StAdjustment *hadjustment,
StAdjustment *vadjustment);
#include <st/st-theme-node.h>
#define ST_TYPE_TEXTURE_CACHE (st_texture_cache_get_type ())
-#define ST_TEXTURE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_TEXTURE_CACHE, StTextureCache))
-#define ST_TEXTURE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_TEXTURE_CACHE, StTextureCacheClass))
-#define ST_IS_TEXTURE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_TEXTURE_CACHE))
-#define ST_IS_TEXTURE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_TEXTURE_CACHE))
-#define ST_TEXTURE_CACHE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_TEXTURE_CACHE, StTextureCacheClass))
-
-typedef struct _StTextureCache StTextureCache;
-typedef struct _StTextureCacheClass StTextureCacheClass;
+G_DECLARE_FINAL_TYPE (StTextureCache, st_texture_cache,
+ ST, TEXTURE_CACHE, GObject)
typedef struct _StTextureCachePrivate StTextureCachePrivate;
StTextureCachePrivate *priv;
};
-struct _StTextureCacheClass
-{
- GObjectClass parent_class;
-
-};
-
typedef enum {
ST_TEXTURE_CACHE_POLICY_NONE,
ST_TEXTURE_CACHE_POLICY_FOREVER
} StTextureCachePolicy;
-GType st_texture_cache_get_type (void) G_GNUC_CONST;
-
StTextureCache* st_texture_cache_get_default (void);
ClutterActor *
int scale_factor;
};
-struct _StThemeContextClass {
- GObjectClass parent_class;
-};
-
#define DEFAULT_FONT "sans-serif 10"
enum
* by using st_theme_context_get_for_stage().
*/
-typedef struct _StThemeContextClass StThemeContextClass;
-
#define ST_TYPE_THEME_CONTEXT (st_theme_context_get_type ())
-#define ST_THEME_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME_CONTEXT, StThemeContext))
-#define ST_THEME_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME_CONTEXT, StThemeContextClass))
-#define ST_IS_THEME_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME_CONTEXT))
-#define ST_IS_THEME_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME_CONTEXT))
-#define ST_THEME_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME_CONTEXT, StThemeContextClass))
-
-GType st_theme_context_get_type (void) G_GNUC_CONST;
+G_DECLARE_FINAL_TYPE (StThemeContext, st_theme_context,
+ ST, THEME_CONTEXT, GObject)
StThemeContext *st_theme_context_new (void);
StThemeContext *st_theme_context_get_for_stage (ClutterStage *stage);
StThemeNodePaintState cached_state;
};
-struct _StThemeNodeClass {
- GObjectClass parent_class;
-
-};
-
void _st_theme_node_ensure_background (StThemeNode *node);
void _st_theme_node_ensure_geometry (StThemeNode *node);
void _st_theme_node_apply_margins (StThemeNode *node,
LAST_SIGNAL
};
+typedef struct _StThemeNodeTransitionPrivate StThemeNodeTransitionPrivate;
+
+struct _StThemeNodeTransition {
+ GObject parent;
+
+ StThemeNodeTransitionPrivate *priv;
+};
+
struct _StThemeNodeTransitionPrivate {
StThemeNode *old_theme_node;
StThemeNode *new_theme_node;
guint duration)
{
StThemeNodeTransition *transition;
-
g_return_val_if_fail (ST_IS_THEME_NODE (from_node), NULL);
g_return_val_if_fail (ST_IS_THEME_NODE (to_node), NULL);
duration = st_theme_node_get_transition_duration (to_node);
- transition = g_object_new (ST_TYPE_THEME_NODE_TRANSITION,
- NULL);
+ transition = g_object_new (ST_TYPE_THEME_NODE_TRANSITION, NULL);
transition->priv->old_theme_node = g_object_ref (from_node);
transition->priv->new_theme_node = g_object_ref (to_node);
st_theme_node_transition_update (StThemeNodeTransition *transition,
StThemeNode *new_node)
{
- StThemeNodeTransitionPrivate *priv = transition->priv;
+ StThemeNodeTransitionPrivate *priv;
StThemeNode *old_node;
ClutterTimelineDirection direction;
g_return_if_fail (ST_IS_THEME_NODE_TRANSITION (transition));
g_return_if_fail (ST_IS_THEME_NODE (new_node));
+ priv = transition->priv;
direction = clutter_timeline_get_direction (priv->timeline);
old_node = (direction == CLUTTER_TIMELINE_FORWARD) ? priv->old_theme_node
: priv->new_theme_node;
G_BEGIN_DECLS
-#define ST_TYPE_THEME_NODE_TRANSITION (st_theme_node_transition_get_type ())
-#define ST_THEME_NODE_TRANSITION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ST_TYPE_THEME_NODE_TRANSITION, StThemeNodeTransition))
-#define ST_IS_THEME_NODE_TRANSITION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ST_TYPE_THEME_NODE_TRANSITION))
-#define ST_THEME_NODE_TRANSITION_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), ST_TYPE_THEME_NODE_TRANSITION, StThemeNodeTransitionClass))
-#define ST_IS_THEME_NODE_TRANSITION_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), ST_TYPE_THEME_NODE_TRANSITION))
-#define ST_THEME_NODE_TRANSITION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ST_THEME_NODE_TRANSITION, StThemeNodeTransitionClass))
-
-typedef struct _StThemeNodeTransition StThemeNodeTransition;
-typedef struct _StThemeNodeTransitionClass StThemeNodeTransitionClass;
-typedef struct _StThemeNodeTransitionPrivate StThemeNodeTransitionPrivate;
-
-struct _StThemeNodeTransition {
- GObject parent;
-
- StThemeNodeTransitionPrivate *priv;
-};
-
-struct _StThemeNodeTransitionClass {
- GObjectClass parent_class;
-};
-
-GType st_theme_node_transition_get_type (void) G_GNUC_CONST;
+#define ST_TYPE_THEME_NODE_TRANSITION (st_theme_node_transition_get_type ())
+G_DECLARE_FINAL_TYPE (StThemeNodeTransition, st_theme_node_transition,
+ ST, THEME_NODE_TRANSITION, GObject)
StThemeNodeTransition *st_theme_node_transition_new (StThemeNode *from_node,
StThemeNode *to_node,
typedef struct _StTheme StTheme;
typedef struct _StThemeContext StThemeContext;
-typedef struct _StThemeNode StThemeNode;
-typedef struct _StThemeNodeClass StThemeNodeClass;
-
#define ST_TYPE_THEME_NODE (st_theme_node_get_type ())
-#define ST_THEME_NODE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME_NODE, StThemeNode))
-#define ST_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME_NODE, StThemeNodeClass))
-#define ST_IS_THEME_NODE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME_NODE))
-#define ST_IS_THEME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME_NODE))
-#define ST_THEME_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME_NODE, StThemeNodeClass))
+G_DECLARE_FINAL_TYPE (StThemeNode, st_theme_node, ST, THEME_NODE, GObject)
typedef enum {
ST_SIDE_TOP,
CoglHandle corner_material[4];
};
-GType st_theme_node_get_type (void) G_GNUC_CONST;
-
StThemeNode *st_theme_node_new (StThemeContext *context,
StThemeNode *parent_node, /* can be null */
StTheme *theme, /* can be null */
CRCascade *cascade;
};
-struct _StThemeClass
-{
- GObjectClass parent_class;
-};
-
enum
{
PROP_0,
* of actors using st_widget_set_theme().
*/
-typedef struct _StThemeClass StThemeClass;
-
#define ST_TYPE_THEME (st_theme_get_type ())
-#define ST_THEME(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_THEME, StTheme))
-#define ST_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_THEME, StThemeClass))
-#define ST_IS_THEME(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_THEME))
-#define ST_IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_THEME))
-#define ST_THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_THEME, StThemeClass))
-
-GType st_theme_get_type (void) G_GNUC_CONST;
+G_DECLARE_FINAL_TYPE (StTheme, st_theme, ST, THEME, GObject)
StTheme *st_theme_new (GFile *application_stylesheet,
GFile *theme_stylesheet,
/*
* Forward declaration for sake of StWidgetChild
*/
+typedef struct _StWidgetPrivate StWidgetPrivate;
struct _StWidgetPrivate
{
StTheme *theme;
gfloat st_slow_down_factor = 1.0;
G_DEFINE_TYPE_WITH_PRIVATE (StWidget, st_widget, CLUTTER_TYPE_ACTOR);
+#define ST_WIDGET_PRIVATE(w) ((StWidgetPrivate *)st_widget_get_instance_private (w))
static void st_widget_recompute_style (StWidget *widget,
StThemeNode *old_theme_node);
GParamSpec *pspec)
{
StWidget *actor = ST_WIDGET (gobject);
- StWidgetPrivate *priv = actor->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (gobject));
switch (prop_id)
{
static void
st_widget_remove_transition (StWidget *widget)
{
- if (widget->priv->transition_animation)
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
+
+ if (priv->transition_animation)
{
- g_object_run_dispose (G_OBJECT (widget->priv->transition_animation));
- g_object_unref (widget->priv->transition_animation);
- widget->priv->transition_animation = NULL;
+ g_object_run_dispose (G_OBJECT (priv->transition_animation));
+ g_object_unref (priv->transition_animation);
+ priv->transition_animation = NULL;
}
}
static void
next_paint_state (StWidget *widget)
{
- widget->priv->current_paint_state = (widget->priv->current_paint_state + 1) % G_N_ELEMENTS (widget->priv->paint_states);
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
+
+ priv->current_paint_state = (priv->current_paint_state + 1) % G_N_ELEMENTS (priv->paint_states);
}
static StThemeNodePaintState *
current_paint_state (StWidget *widget)
{
- return &widget->priv->paint_states[widget->priv->current_paint_state];
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
+
+ return &priv->paint_states[priv->current_paint_state];
}
static void
gpointer user_data)
{
StWidget *actor = ST_WIDGET (user_data);
- StThemeNode *node = actor->priv->theme_node;
+ StWidgetPrivate *priv = st_widget_get_instance_private (actor);
+ StThemeNode *node = priv->theme_node;
gboolean changed = FALSE;
GFile *theme_file;
st_widget_dispose (GObject *gobject)
{
StWidget *actor = ST_WIDGET (gobject);
- StWidgetPrivate *priv = ST_WIDGET (actor)->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (actor);
g_clear_pointer (&priv->theme, g_object_unref);
g_clear_pointer (&priv->theme_node, g_object_unref);
static void
st_widget_finalize (GObject *gobject)
{
- StWidgetPrivate *priv = ST_WIDGET (gobject)->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (gobject));
guint i;
g_free (priv->style_class);
void
st_widget_paint_background (StWidget *widget)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
StThemeNode *theme_node;
ClutterActorBox allocation;
guint8 opacity;
opacity = clutter_actor_get_paint_opacity (CLUTTER_ACTOR (widget));
- if (widget->priv->transition_animation)
- st_theme_node_transition_paint (widget->priv->transition_animation,
+ if (priv->transition_animation)
+ st_theme_node_transition_paint (priv->transition_animation,
&allocation,
opacity);
else
st_widget_unmap (ClutterActor *actor)
{
StWidget *self = ST_WIDGET (actor);
- StWidgetPrivate *priv = self->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (self);
CLUTTER_ACTOR_CLASS (st_widget_parent_class)->unmap (actor);
void
st_widget_style_changed (StWidget *widget)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
StThemeNode *old_theme_node = NULL;
- widget->priv->is_style_dirty = TRUE;
- if (widget->priv->theme_node)
+ priv->is_style_dirty = TRUE;
+ if (priv->theme_node)
{
- old_theme_node = widget->priv->theme_node;
- widget->priv->theme_node = NULL;
+ old_theme_node = priv->theme_node;
+ priv->theme_node = NULL;
}
/* update the style only if we are mapped */
StThemeNode *
st_widget_get_theme_node (StWidget *widget)
{
- StWidgetPrivate *priv = widget->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
if (priv->theme_node == NULL)
{
StThemeNode *
st_widget_peek_theme_node (StWidget *widget)
{
- StWidgetPrivate *priv = widget->priv;
+ g_return_val_if_fail (ST_IS_WIDGET (widget), NULL);
- return priv->theme_node;
+ return ST_WIDGET_PRIVATE (widget)->theme_node;
}
static gboolean
st_widget_enter (ClutterActor *actor,
ClutterCrossingEvent *event)
{
- StWidgetPrivate *priv = ST_WIDGET (actor)->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (actor));
if (priv->track_hover)
{
st_widget_leave (ClutterActor *actor,
ClutterCrossingEvent *event)
{
- StWidgetPrivate *priv = ST_WIDGET (actor)->priv;
+ StWidgetPrivate *priv = st_widget_get_instance_private (ST_WIDGET (actor));
if (priv->track_hover)
{
if (!clutter_actor_has_allocation (self))
return FALSE;
- priv = ST_WIDGET (self)->priv;
+ priv = st_widget_get_instance_private (ST_WIDGET (self));
theme_node = st_widget_get_theme_node (ST_WIDGET (self));
clutter_actor_get_allocation_box (self, &alloc_box);
g_return_if_fail (ST_IS_WIDGET (actor));
- priv = actor->priv;
+ priv = st_widget_get_instance_private (actor);
if (theme != priv->theme)
{
{
g_return_val_if_fail (ST_IS_WIDGET (actor), NULL);
- return actor->priv->theme;
+ return ST_WIDGET_PRIVATE (actor)->theme;
}
static const gchar *
st_widget_set_style_class_name (StWidget *actor,
const gchar *style_class_list)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
- if (set_class_list (&actor->priv->style_class, style_class_list))
+ priv = st_widget_get_instance_private (actor);
+
+ if (set_class_list (&priv->style_class, style_class_list))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "style-class");
st_widget_add_style_class_name (StWidget *actor,
const gchar *style_class)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
g_return_if_fail (style_class != NULL);
- if (add_class_name (&actor->priv->style_class, style_class))
+ priv = st_widget_get_instance_private (actor);
+
+ if (add_class_name (&priv->style_class, style_class))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "style-class");
st_widget_remove_style_class_name (StWidget *actor,
const gchar *style_class)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
g_return_if_fail (style_class != NULL);
- if (remove_class_name (&actor->priv->style_class, style_class))
+ priv = st_widget_get_instance_private (actor);
+
+ if (remove_class_name (&priv->style_class, style_class))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "style-class");
{
g_return_val_if_fail (ST_IS_WIDGET (actor), NULL);
- return actor->priv->style_class;
+ return ST_WIDGET_PRIVATE (actor)->style_class;
}
/**
st_widget_has_style_class_name (StWidget *actor,
const gchar *style_class)
{
+ StWidgetPrivate *priv;
+
g_return_val_if_fail (ST_IS_WIDGET (actor), FALSE);
- return find_class_name (actor->priv->style_class, style_class) != NULL;
+ priv = st_widget_get_instance_private (actor);
+
+ return find_class_name (priv->style_class, style_class) != NULL;
}
/**
{
g_return_val_if_fail (ST_IS_WIDGET (actor), NULL);
- return actor->priv->pseudo_class;
+ return ST_WIDGET_PRIVATE (actor)->pseudo_class;
}
/**
st_widget_has_style_pseudo_class (StWidget *actor,
const gchar *pseudo_class)
{
+ StWidgetPrivate *priv;
+
g_return_val_if_fail (ST_IS_WIDGET (actor), FALSE);
- return find_class_name (actor->priv->pseudo_class, pseudo_class) != NULL;
+ priv = st_widget_get_instance_private (actor);
+
+ return find_class_name (priv->pseudo_class, pseudo_class) != NULL;
}
/**
st_widget_set_style_pseudo_class (StWidget *actor,
const gchar *pseudo_class_list)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
- if (set_class_list (&actor->priv->pseudo_class, pseudo_class_list))
+ priv = st_widget_get_instance_private (actor);
+
+ if (set_class_list (&priv->pseudo_class, pseudo_class_list))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "pseudo-class");
st_widget_add_style_pseudo_class (StWidget *actor,
const gchar *pseudo_class)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
g_return_if_fail (pseudo_class != NULL);
- if (add_class_name (&actor->priv->pseudo_class, pseudo_class))
+ priv = st_widget_get_instance_private (actor);
+
+ if (add_class_name (&priv->pseudo_class, pseudo_class))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "pseudo-class");
st_widget_remove_style_pseudo_class (StWidget *actor,
const gchar *pseudo_class)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (actor));
g_return_if_fail (pseudo_class != NULL);
- if (remove_class_name (&actor->priv->pseudo_class, pseudo_class))
+ priv = st_widget_get_instance_private (actor);
+
+ if (remove_class_name (&priv->pseudo_class, pseudo_class))
{
st_widget_style_changed (actor);
g_object_notify (G_OBJECT (actor), "pseudo-class");
g_return_if_fail (ST_IS_WIDGET (actor));
- priv = actor->priv;
+ priv = st_widget_get_instance_private (actor);
if (g_strcmp0 (style, priv->inline_style))
{
{
g_return_val_if_fail (ST_IS_WIDGET (actor), NULL);
- return actor->priv->inline_style;
+ return ST_WIDGET_PRIVATE (actor)->inline_style;
}
static void
GParamSpec *pspec,
gpointer data)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
+
if (clutter_actor_get_reactive (CLUTTER_ACTOR (widget)))
st_widget_remove_style_pseudo_class (widget, "insensitive");
else
st_widget_add_style_pseudo_class (widget, "insensitive");
- if (widget->priv->track_hover)
+ if (priv->track_hover)
st_widget_sync_hover(widget);
}
GParamSpec *pspec,
gpointer data)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
ClutterActor *first_child;
- if (widget->priv->prev_first_child != NULL)
+ if (priv->prev_first_child != NULL)
{
- st_widget_remove_style_pseudo_class (widget->priv->prev_first_child, "first-child");
- g_clear_object (&widget->priv->prev_first_child);
+ st_widget_remove_style_pseudo_class (priv->prev_first_child, "first-child");
+ g_clear_object (&priv->prev_first_child);
}
first_child = clutter_actor_get_first_child (CLUTTER_ACTOR (widget));
if (ST_IS_WIDGET (first_child))
{
st_widget_add_style_pseudo_class (ST_WIDGET (first_child), "first-child");
- widget->priv->prev_first_child = g_object_ref (ST_WIDGET (first_child));
+ priv->prev_first_child = g_object_ref (ST_WIDGET (first_child));
}
}
GParamSpec *pspec,
gpointer data)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
ClutterActor *last_child;
- if (widget->priv->prev_last_child != NULL)
+ if (priv->prev_last_child != NULL)
{
- st_widget_remove_style_pseudo_class (widget->priv->prev_last_child, "last-child");
- g_clear_object (&widget->priv->prev_last_child);
+ st_widget_remove_style_pseudo_class (priv->prev_last_child, "last-child");
+ g_clear_object (&priv->prev_last_child);
}
last_child = clutter_actor_get_last_child (CLUTTER_ACTOR (widget));
if (ST_IS_WIDGET (last_child))
{
st_widget_add_style_pseudo_class (ST_WIDGET (last_child), "last-child");
- widget->priv->prev_last_child = g_object_ref (ST_WIDGET (last_child));
+ priv->prev_last_child = g_object_ref (ST_WIDGET (last_child));
}
}
StWidgetPrivate *priv;
guint i;
- actor->priv = priv = st_widget_get_instance_private (actor);
+ priv = st_widget_get_instance_private (actor);
priv->transition_animation = NULL;
priv->local_state_set = atk_state_set_new ();
st_widget_recompute_style (StWidget *widget,
StThemeNode *old_theme_node)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
StThemeNode *new_theme_node = st_widget_get_theme_node (widget);
int transition_duration;
gboolean paint_equal;
if (new_theme_node == old_theme_node)
{
- widget->priv->is_style_dirty = FALSE;
+ priv->is_style_dirty = FALSE;
return;
}
if (animations_enabled && transition_duration > 0)
{
- if (widget->priv->transition_animation != NULL)
+ if (priv->transition_animation != NULL)
{
- st_theme_node_transition_update (widget->priv->transition_animation,
+ st_theme_node_transition_update (priv->transition_animation,
new_theme_node);
}
else if (old_theme_node && !paint_equal)
* we can't animate that anyways.
*/
- widget->priv->transition_animation =
+ priv->transition_animation =
st_theme_node_transition_new (old_theme_node,
new_theme_node,
current_paint_state (widget),
transition_duration);
- g_signal_connect (widget->priv->transition_animation, "completed",
+ g_signal_connect (priv->transition_animation, "completed",
G_CALLBACK (on_transition_completed), widget);
- g_signal_connect_swapped (widget->priv->transition_animation,
+ g_signal_connect_swapped (priv->transition_animation,
"new-frame",
G_CALLBACK (clutter_actor_queue_redraw),
widget);
}
}
- else if (widget->priv->transition_animation)
+ else if (priv->transition_animation)
{
st_widget_remove_transition (widget);
}
}
g_signal_emit (widget, signals[STYLE_CHANGED], 0);
- widget->priv->is_style_dirty = FALSE;
+ priv->is_style_dirty = FALSE;
}
/**
void
st_widget_ensure_style (StWidget *widget)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- if (widget->priv->is_style_dirty)
+ priv = st_widget_get_instance_private (widget);
+
+ if (priv->is_style_dirty)
st_widget_recompute_style (widget, NULL);
}
g_return_if_fail (ST_IS_WIDGET (widget));
- priv = widget->priv;
+ priv = st_widget_get_instance_private (widget);
if (priv->track_hover != track_hover)
{
{
g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE);
- return widget->priv->track_hover;
+ return ST_WIDGET_PRIVATE (widget)->track_hover;
}
/**
g_return_if_fail (ST_IS_WIDGET (widget));
- priv = widget->priv;
+ priv = st_widget_get_instance_private (widget);
if (priv->hover != hover)
{
{
g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE);
- return widget->priv->hover;
+ return ST_WIDGET_PRIVATE (widget)->hover;
}
/**
g_return_if_fail (ST_IS_WIDGET (widget));
- priv = widget->priv;
+ priv = st_widget_get_instance_private (widget);
if (priv->can_focus != can_focus)
{
{
g_return_val_if_fail (ST_IS_WIDGET (widget), FALSE);
- return widget->priv->can_focus;
+ return ST_WIDGET_PRIVATE (widget)->can_focus;
}
/**
ClutterActor *from,
GtkDirectionType direction)
{
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
ClutterActor *widget_actor, *focus_child;
GList *children, *l;
while (focus_child && clutter_actor_get_parent (focus_child) != widget_actor)
focus_child = clutter_actor_get_parent (focus_child);
- if (widget->priv->can_focus)
+ if (priv->can_focus)
{
if (!focus_child)
{
{
g_return_val_if_fail (ST_IS_WIDGET (widget), NULL);
- return widget->priv->label_actor;
+ return ST_WIDGET_PRIVATE (widget)->label_actor;
}
/**
st_widget_set_label_actor (StWidget *widget,
ClutterActor *label)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- if (widget->priv->label_actor != label)
+ priv = st_widget_get_instance_private (widget);
+
+ if (priv->label_actor != label)
{
- if (widget->priv->label_actor)
- g_object_unref (widget->priv->label_actor);
+ if (priv->label_actor)
+ g_object_unref (priv->label_actor);
if (label != NULL)
- widget->priv->label_actor = g_object_ref (label);
+ priv->label_actor = g_object_ref (label);
else
- widget->priv->label_actor = NULL;
+ priv->label_actor = NULL;
g_object_notify (G_OBJECT (widget), "label-actor");
}
st_widget_set_accessible_name (StWidget *widget,
const gchar *name)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- if (widget->priv->accessible_name != NULL)
- g_free (widget->priv->accessible_name);
+ priv = st_widget_get_instance_private (widget);
+
+ if (priv->accessible_name != NULL)
+ g_free (priv->accessible_name);
- widget->priv->accessible_name = g_strdup (name);
+ priv->accessible_name = g_strdup (name);
g_object_notify (G_OBJECT (widget), "accessible-name");
}
{
g_return_val_if_fail (ST_IS_WIDGET (widget), NULL);
- return widget->priv->accessible_name;
+ return ST_WIDGET_PRIVATE (widget)->accessible_name;
}
/**
st_widget_set_accessible_role (StWidget *widget,
AtkRole role)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- widget->priv->accessible_role = role;
+ priv = st_widget_get_instance_private (widget);
+ priv->accessible_role = role;
g_object_notify (G_OBJECT (widget), "accessible-role");
}
AtkRole
st_widget_get_accessible_role (StWidget *widget)
{
+ StWidgetPrivate *priv;
AtkObject *accessible = NULL;
AtkRole role = ATK_ROLE_INVALID;
g_return_val_if_fail (ST_IS_WIDGET (widget), ATK_ROLE_INVALID);
- if (widget->priv->accessible_role != ATK_ROLE_INVALID)
- role = widget->priv->accessible_role;
- else if (widget->priv->accessible != NULL)
+ priv = st_widget_get_instance_private (widget);
+
+ if (priv->accessible_role != ATK_ROLE_INVALID)
+ role = priv->accessible_role;
+ else if (priv->accessible != NULL)
role = atk_object_get_role (accessible);
return role;
AtkStateType state,
gboolean value)
{
- if (widget->priv->accessible != NULL)
- atk_object_notify_state_change (widget->priv->accessible, state, value);
+ StWidgetPrivate *priv = st_widget_get_instance_private (widget);
+
+ if (priv->accessible != NULL)
+ atk_object_notify_state_change (priv->accessible, state, value);
}
/**
st_widget_add_accessible_state (StWidget *widget,
AtkStateType state)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- if (atk_state_set_add_state (widget->priv->local_state_set, state))
+ priv = st_widget_get_instance_private (widget);
+
+ if (atk_state_set_add_state (priv->local_state_set, state))
notify_accessible_state_change (widget, state, TRUE);
}
st_widget_remove_accessible_state (StWidget *widget,
AtkStateType state)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
- if (atk_state_set_remove_state (widget->priv->local_state_set, state))
+ priv = st_widget_get_instance_private (widget);
+
+ if (atk_state_set_remove_state (priv->local_state_set, state))
notify_accessible_state_change (widget, state, FALSE);
}
st_widget_get_accessible (ClutterActor *actor)
{
StWidget *widget = NULL;
+ StWidgetPrivate *priv;
g_return_val_if_fail (ST_IS_WIDGET (actor), NULL);
widget = ST_WIDGET (actor);
+ priv = st_widget_get_instance_private (widget);
- if (widget->priv->accessible == NULL)
+ if (priv->accessible == NULL)
{
- widget->priv->accessible =
+ priv->accessible =
g_object_new (ST_WIDGET_GET_CLASS (widget)->get_accessible_type (),
NULL);
- atk_object_initialize (widget->priv->accessible, actor);
+ atk_object_initialize (priv->accessible, actor);
/* AtkGObjectAccessible, which StWidgetAccessible derives from, clears
* the back reference to the object in a weak notify for the object;
* will result in a new accessible object being created.
*/
g_object_add_weak_pointer (G_OBJECT (actor),
- (gpointer *)&widget->priv->accessible);
+ (gpointer *)&priv->accessible);
}
- return widget->priv->accessible;
+ return priv->accessible;
}
/**
st_widget_set_accessible (StWidget *widget,
AtkObject *accessible)
{
+ StWidgetPrivate *priv;
+
g_return_if_fail (ST_IS_WIDGET (widget));
g_return_if_fail (accessible == NULL || ATK_IS_GOBJECT_ACCESSIBLE (accessible));
- if (widget->priv->accessible != accessible)
+ priv = st_widget_get_instance_private (widget);
+
+ if (priv->accessible != accessible)
{
- if (widget->priv->accessible)
+ if (priv->accessible)
{
g_object_remove_weak_pointer (G_OBJECT (widget),
- (gpointer *)&widget->priv->accessible);
- g_object_unref (widget->priv->accessible);
- widget->priv->accessible = NULL;
+ (gpointer *)&priv->accessible);
+ g_object_unref (priv->accessible);
+ priv->accessible = NULL;
}
if (accessible)
{
- widget->priv->accessible = g_object_ref (accessible);
+ priv->accessible = g_object_ref (accessible);
/* See note in st_widget_get_accessible() */
g_object_add_weak_pointer (G_OBJECT (widget),
- (gpointer *)&widget->priv->accessible);
+ (gpointer *)&priv->accessible);
}
else
- widget->priv->accessible = NULL;
+ priv->accessible = NULL;
}
}
if (widget == NULL)
name = NULL;
else
- name = widget->priv->accessible_name;
+ name = st_widget_get_accessible_name (widget);
}
return name;
AtkStateSet *aux_set = NULL;
ClutterActor *actor = NULL;
StWidget *widget = NULL;
+ StWidgetPrivate *widget_priv;
StWidgetAccessible *self = NULL;
result = ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->ref_state_set (obj);
widget = ST_WIDGET (actor);
self = ST_WIDGET_ACCESSIBLE (obj);
+ widget_priv = st_widget_get_instance_private (widget);
/* priv->selected should be properly updated on the
* ATK_STATE_SELECTED notification callbacks
atk_state_set_remove_state (result, ATK_STATE_FOCUSABLE);
/* We add the states added externally if required */
- if (!atk_state_set_is_empty (widget->priv->local_state_set))
+ if (!atk_state_set_is_empty (widget_priv->local_state_set))
{
- aux_set = atk_state_set_or_sets (result, widget->priv->local_state_set);
+ aux_set = atk_state_set_or_sets (result, widget_priv->local_state_set);
g_object_unref (result); /* previous result will not be used */
result = aux_set;
st_widget_accessible_get_role (AtkObject *obj)
{
StWidget *widget = NULL;
+ AtkRole role;
g_return_val_if_fail (ST_IS_WIDGET_ACCESSIBLE (obj), ATK_ROLE_INVALID);
if (widget == NULL)
return ATK_ROLE_INVALID;
- if (widget->priv->accessible_role != ATK_ROLE_INVALID)
- return widget->priv->accessible_role;
+ role = st_widget_get_accessible_role (widget);
+ if (role != ATK_ROLE_INVALID)
+ return role;
return ATK_OBJECT_CLASS (st_widget_accessible_parent_class)->get_role (obj);
}
G_BEGIN_DECLS
#define ST_TYPE_WIDGET (st_widget_get_type ())
-#define ST_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_WIDGET, StWidget))
-#define ST_IS_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_WIDGET))
-#define ST_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_WIDGET, StWidgetClass))
-#define ST_IS_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_WIDGET))
-#define ST_WIDGET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_WIDGET, StWidgetClass))
-
-typedef struct _StWidget StWidget;
-typedef struct _StWidgetPrivate StWidgetPrivate;
-typedef struct _StWidgetClass StWidgetClass;
-
-/**
- * StWidget:
- *
- * Base class for stylable actors. The contents of the #StWidget
- * structure are private and should only be accessed through the
- * public API.
- */
-struct _StWidget
-{
- /*< private >*/
- ClutterActor parent_instance;
+G_DECLARE_DERIVABLE_TYPE (StWidget, st_widget, ST, WIDGET, ClutterActor)
- StWidgetPrivate *priv;
-};
+typedef struct _StWidgetClass StWidgetClass;
/**
* StWidgetClass:
GList * (* get_focus_chain) (StWidget *widget);
};
-GType st_widget_get_type (void) G_GNUC_CONST;
-
void st_widget_set_style_pseudo_class (StWidget *actor,
const gchar *pseudo_class_list);
void st_widget_add_style_pseudo_class (StWidget *actor,
projects / gnome-shell.git / commitdiff